home *** CD-ROM | disk | FTP | other *** search
/ Freelog 115 / FreelogNo115-MaiJuin2013.iso / Internet / Filezilla Server / FileZilla_Server-0_9_41.exe / source / AsyncGssSocketLayer.cpp < prev    next >
C/C++ Source or Header  |  2011-11-06  |  31KB  |  1,190 lines
  1. // GSSAsyncSocksifiedSocket.cpp: implementation of the CAsyncGssSocketLayer class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  4. // Part of this code is copyright 2001 Massachusetts Institute of Technology
  5.  
  6. #include "stdafx.h"
  7. #include "resource.h"
  8. #include "AsyncGssSocketLayer.h"
  9.  
  10. //////////////////////////////////////////////////////////////////////
  11. // Construction/Destruction
  12. //////////////////////////////////////////////////////////////////////
  13.  
  14. #define BUFSIZE (1024*8)
  15.  
  16. CAsyncGssSocketLayer::CAsyncGssSocketLayer()
  17. {
  18.     m_hGSS_API = NULL;
  19.     m_transfer = FALSE;
  20.     m_bInitialized=FALSE;
  21.     m_bUseGSS=FALSE;
  22.     m_nGssNetworkError=0;
  23.     m_gotAuth=0;
  24.     m_nShutDown = 0;
  25.  
  26.     pFzGss_ProcessCommand = NULL;
  27.     pFzGss_InitGSS = NULL;
  28.     pFzGss_KillGSS = NULL;
  29.     pFzGss_DecryptMessage = NULL;
  30.     pFzGss_EncryptMessage = NULL;
  31.     pFzGss_EncryptData = NULL;
  32.     pFzGss_DecryptData = NULL;
  33.  
  34.     m_pSendBuffer = NULL;
  35.     m_nSendBufferLen = 0;
  36.     m_nSendBufferSize = 0;
  37.  
  38.     m_pReceiveBuffer = NULL;
  39.     m_nReceiveBufferLen = 0;
  40.     m_nReceiveBufferSize = 0;
  41.  
  42.     m_pDecryptedReceiveBuffer = NULL;
  43.     m_nDecryptedReceiveBufferLen = 0;
  44.     m_nDecryptedReceiveBufferSize = 0;
  45.  
  46.     m_nAwaitingReply = 0;
  47. }
  48.  
  49. CAsyncGssSocketLayer::~CAsyncGssSocketLayer()
  50. {
  51.     delete [] m_pSendBuffer;
  52.     delete [] m_pReceiveBuffer;
  53.     delete [] m_pDecryptedReceiveBuffer;
  54.     
  55.     KillGSSData();
  56. }
  57.  
  58. int CAsyncGssSocketLayer::Send(const void* lpBuf, int nBufLen, int nFlags)
  59. {
  60.     if (m_gotAuth == GSSAPI_AUTHENTICATION_SUCCEEDED && m_bUseGSS)
  61.     {
  62.         if (m_nAwaitingReply == 3)
  63.         {
  64.             m_nAwaitingReply = 0;
  65.             int res = SendNext(lpBuf, nBufLen, nFlags);
  66.             if (res == nBufLen)
  67.                 m_nAwaitingReply = 0;
  68.             return res;
  69.         }
  70.         if (m_nShutDown)
  71.         {
  72.             SetLastError(WSAESHUTDOWN);
  73.             return SOCKET_ERROR;
  74.         }
  75.         
  76.         if (!nBufLen)
  77.             return 0;
  78.  
  79.         if (m_nSendBufferLen > BUFSIZE)
  80.         {
  81.             SetLastError(WSAEWOULDBLOCK);
  82.             return SOCKET_ERROR;
  83.         }
  84.  
  85.         char sendme[4096];
  86.         char *encBuffer = m_tmpBuffer;
  87.         int encBufferLen = 0;
  88.  
  89.         if ((nBufLen*1.5) > (1024*32))
  90.             encBuffer = new char[(int)(nBufLen * 1.5)];
  91.         memcpy(encBuffer, (char*)lpBuf, nBufLen);
  92.  
  93.         if (m_transfer)
  94.         {
  95.             if (nBufLen>4000)
  96.                 nBufLen=4000;
  97.             
  98.             encBuffer[nBufLen] = '\0';
  99.             encBufferLen = pFzGss_EncryptData(m_pData, encBuffer, nBufLen, sendme);
  100.         
  101.             if (!encBufferLen)
  102.             {
  103.                 if (encBuffer != m_tmpBuffer)
  104.                     delete [] encBuffer;
  105.                 return 0;
  106.             }
  107.         }
  108.         else
  109.         {
  110.             encBuffer[nBufLen]='\0';
  111.             int len = pFzGss_EncryptMessage(m_pData, encBuffer, sendme);
  112.             if (!len) 
  113.             {
  114.                 if (encBuffer != m_tmpBuffer)
  115.                     delete [] encBuffer;
  116.                 return 0;
  117.             }
  118.  
  119.             char *str = new char[strlen(encBuffer) + 30];
  120.             sprintf(str, "Encrypted command: %s", encBuffer);
  121.             DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_INFO, (int)str);
  122.             delete [] str;
  123.             strcat(encBuffer, "\r\n");
  124.             encBufferLen = strlen(encBuffer);
  125.         }
  126.  
  127.         if (m_nSendBufferLen)
  128.         {
  129.             ASSERT(m_nSendBufferLen <= m_nSendBufferSize);
  130.             ASSERT(m_pSendBuffer);
  131.             int numsent = SendNext(m_pSendBuffer, m_nSendBufferLen, 0);
  132.             if (!numsent)
  133.             {
  134.                 if (encBuffer != m_tmpBuffer)
  135.                     delete [] encBuffer;
  136.                 return 0;
  137.             }
  138.             else if (numsent == SOCKET_ERROR && GetLastError()!=WSAEWOULDBLOCK)
  139.             {
  140.                 if (encBuffer != m_tmpBuffer)
  141.                     delete [] encBuffer;
  142.                 return SOCKET_ERROR;
  143.             }
  144.             else if (numsent != m_nSendBufferLen)
  145.             {
  146.                 if (numsent == SOCKET_ERROR)
  147.                     numsent = 0;
  148.                 if (!m_pSendBuffer)
  149.                 {
  150.                     m_pSendBuffer = new char[encBufferLen * 2];
  151.                     m_nSendBufferSize = encBufferLen * 2;
  152.                 }
  153.                 else if (m_nSendBufferSize < (m_nSendBufferLen + encBufferLen))
  154.                 {
  155.                     char *tmp = m_pSendBuffer;
  156.                     m_pSendBuffer = new char[m_nSendBufferSize + encBufferLen + 4096];
  157.                     m_nSendBufferSize = m_nSendBufferSize + encBufferLen + 4096;
  158.                     memcpy(m_pSendBuffer, tmp+numsent, m_nSendBufferLen-numsent);
  159.                     delete [] tmp;
  160.                 }
  161.                 else
  162.                     memmove(m_pSendBuffer, m_pSendBuffer + numsent, m_nSendBufferLen - numsent);
  163.                 memcpy(m_pSendBuffer + m_nSendBufferLen - numsent, encBuffer, encBufferLen);
  164.                 m_nSendBufferLen += encBufferLen-numsent;
  165.  
  166.                 if (encBuffer != m_tmpBuffer)
  167.                     delete [] encBuffer;
  168.  
  169.                 return nBufLen;
  170.             }
  171.             else
  172.                 m_nSendBufferLen = 0;
  173.         }
  174.  
  175.         int numsent = SendNext(encBuffer, encBufferLen, 0);
  176.         if (!numsent)
  177.         {
  178.             if (encBuffer != m_tmpBuffer)
  179.                 delete [] encBuffer;
  180.             return 0;
  181.         }
  182.         if (numsent == SOCKET_ERROR)
  183.         {
  184.             if (GetLastError() != WSAEWOULDBLOCK)
  185.             {
  186.                 if (encBuffer != m_tmpBuffer)
  187.                     delete [] encBuffer;
  188.                 return SOCKET_ERROR;
  189.             }
  190.             else
  191.             {
  192.                 if (m_nSendBufferSize < encBufferLen)
  193.                 {
  194.                     delete [] m_pSendBuffer;
  195.                     m_pSendBuffer = new char[encBufferLen * 2];
  196.                     m_nSendBufferSize = encBufferLen * 2;
  197.                 }
  198.  
  199.                 memcpy(m_pSendBuffer, encBuffer, encBufferLen);
  200.                 m_nSendBufferLen = encBufferLen;
  201.             }
  202.         }
  203.         else if (numsent != encBufferLen)
  204.         {
  205.             if (m_nSendBufferSize < encBufferLen)
  206.             {
  207.                 delete [] m_pSendBuffer;
  208.                 m_pSendBuffer = new char[encBufferLen * 2];
  209.                 m_nSendBufferSize = encBufferLen * 2;
  210.             }
  211.             memcpy(m_pSendBuffer, encBuffer+numsent, encBufferLen-numsent);
  212.             m_nSendBufferLen = encBufferLen-numsent;
  213.         }
  214.  
  215.         if (encBuffer != m_tmpBuffer)
  216.             delete [] encBuffer;
  217.         
  218.         return nBufLen;
  219.     }
  220.     else
  221.         return SendNext(lpBuf, nBufLen, nFlags);
  222. }
  223. /*
  224. This method calls its super method to receive data.
  225. If authentication succeeded at some point, then it tries to decrypt the data.
  226. After decryption, it adds \r\n to the end of the buffer.
  227. This method currently does not handle the MSG_PEEK flag, it also ignores nBufLen.
  228. */
  229. int CAsyncGssSocketLayer::Receive(void *lpBuf, int nBufLen, int nFlags)
  230. {
  231.     if (m_gotAuth == GSSAPI_AUTHENTICATION_SUCCEEDED && m_bUseGSS)
  232.     {
  233.         if (m_nShutDown)
  234.         {
  235.             SetLastError(WSAESHUTDOWN);
  236.             return SOCKET_ERROR;
  237.         }
  238.  
  239.         if (!nBufLen)
  240.             return 0;
  241.     
  242.         BOOL bTriggerRead = TRUE;
  243.         if (!m_nDecryptedReceiveBufferLen)
  244.         {
  245.             bTriggerRead = FALSE;
  246.             OnReceive(0);
  247.         }
  248.         
  249.         if (m_nDecryptedReceiveBufferLen)
  250.         {
  251.             ASSERT(m_pDecryptedReceiveBuffer && m_nDecryptedReceiveBufferLen<=m_nDecryptedReceiveBufferSize);
  252.             if (m_nDecryptedReceiveBufferLen > nBufLen)
  253.             {
  254.                 memcpy(lpBuf, m_pDecryptedReceiveBuffer, nBufLen);
  255.                 memmove(m_pDecryptedReceiveBuffer, m_pDecryptedReceiveBuffer + nBufLen, m_nDecryptedReceiveBufferLen-nBufLen);
  256.                 m_nDecryptedReceiveBufferLen -= nBufLen;
  257.                 ASSERT(nBufLen>0);
  258.  
  259.                 if (bTriggerRead)
  260.                     TriggerEvent(FD_READ, 0);
  261.  
  262.                 return nBufLen;
  263.             }
  264.             else if (m_nDecryptedReceiveBufferLen == nBufLen)
  265.             {
  266.                 memcpy(lpBuf, m_pDecryptedReceiveBuffer, nBufLen);
  267.                 m_nDecryptedReceiveBufferLen = 0;
  268.  
  269.                 if (m_nGssNetworkError == -1)
  270.                 {
  271.                     //Trigger OnClose()
  272.                     TriggerEvent(FD_CLOSE, 0, TRUE);
  273.                 }
  274.                 else if (bTriggerRead)
  275.                     TriggerEvent(FD_READ, 0);
  276.  
  277.                 return nBufLen;
  278.             }
  279.             else
  280.             {
  281.                 memcpy(lpBuf, m_pDecryptedReceiveBuffer, m_nDecryptedReceiveBufferLen);
  282.                 int res = m_nDecryptedReceiveBufferLen;
  283.                 m_nDecryptedReceiveBufferLen = 0;
  284.  
  285.                 if (m_nGssNetworkError == -1)
  286.                 {
  287.                     //Trigger OnClose()
  288.                     TriggerEvent(FD_CLOSE, 0, TRUE);
  289.                 }
  290.                 else if (bTriggerRead)
  291.                     TriggerEvent(FD_READ, 0);
  292.                 
  293.                 return res;
  294.             }
  295.         }
  296.         else
  297.         {
  298.             if (m_nGssNetworkError==-1)
  299.                 return 0;
  300.             else if (m_nGssNetworkError)
  301.             {
  302.                 WSASetLastError(m_nGssNetworkError);
  303.                 return SOCKET_ERROR;
  304.             }
  305.             else
  306.             {
  307.                 WSASetLastError(WSAEWOULDBLOCK);
  308.                 return SOCKET_ERROR;
  309.             }
  310.         }
  311.     }
  312.     else
  313.         return ReceiveNext(lpBuf, nBufLen, nFlags);
  314. }
  315.  
  316. void CAsyncGssSocketLayer::OnReceive(int nErrorCode) 
  317. {
  318.     if (!m_bUseGSS || m_gotAuth != GSSAPI_AUTHENTICATION_SUCCEEDED)
  319.     {
  320.         TriggerEvent(FD_READ, nErrorCode, TRUE);
  321.         return;
  322.     }
  323.  
  324.     //Don't decrypt additional data if buffer for decrypted data is not empty
  325.     if (m_nDecryptedReceiveBufferLen && (GetLayerState()==attached || GetLayerState()==connected))
  326.     {
  327.         TriggerEvent(FD_READ, nErrorCode, TRUE);
  328.         return;
  329.     }
  330.  
  331.     char sendme[4096];
  332.     //TRACE(m_transfer?"GSS OnReceive: called, transfer mode\n":"GSS OnReceive: called\n");
  333.     int count = 10;
  334.     while(count--)
  335.     {
  336.         if (m_transfer)
  337.         {
  338.             if (m_nReceiveBufferLen < 4)
  339.             {
  340.                 if (!m_pReceiveBuffer)
  341.                 {
  342.                     ASSERT(!m_nReceiveBufferLen);
  343.                     ASSERT(!m_nReceiveBufferSize);
  344.                     m_pReceiveBuffer = new char[4096];
  345.                     m_nReceiveBufferSize = 4096;
  346.                     m_nReceiveBufferLen = 0;
  347.                 }
  348.                 int numread = ReceiveNext(m_pReceiveBuffer+m_nReceiveBufferLen, 4 - m_nReceiveBufferLen);
  349.                 if (!numread)
  350.                 {
  351.                     m_nGssNetworkError = -1;
  352.                     if (!m_nDecryptedReceiveBufferLen)
  353.                         TriggerEvent(FD_CLOSE, 0, TRUE);
  354.                     return;
  355.                 }
  356.                 else if (numread == SOCKET_ERROR)
  357.                 {
  358.                     if (GetLastError() != WSAEWOULDBLOCK)
  359.                     {
  360.                         TriggerEvent(FD_CLOSE, 0, TRUE);
  361.                         m_nGssNetworkError = GetLastError();
  362.                     }
  363.                     else
  364.                         if (m_nDecryptedReceiveBufferLen)
  365.                             TriggerEvent(FD_READ, nErrorCode, TRUE);
  366.                     return;
  367.                 }
  368.                 m_nReceiveBufferLen += numread;
  369.                 
  370.                 if (m_nReceiveBufferLen != 4)
  371.                 {
  372.                     if (m_nDecryptedReceiveBufferLen)
  373.                         TriggerEvent(FD_READ, nErrorCode, TRUE);
  374.                     return;
  375.                 }
  376.  
  377.                 char tmp = m_pReceiveBuffer[0];
  378.                 m_pReceiveBuffer[0] = m_pReceiveBuffer[3];
  379.                 m_pReceiveBuffer[3] = tmp;
  380.                 tmp = m_pReceiveBuffer[1];
  381.                 m_pReceiveBuffer[1] = m_pReceiveBuffer[2];
  382.                 m_pReceiveBuffer[2] = tmp;
  383.                 unsigned int len = *(unsigned int*)m_pReceiveBuffer;
  384.                 if (len<4 || len > (1024*1024*4))
  385.                 {
  386.                     m_nGssNetworkError = WSAEMSGSIZE;
  387.                     TriggerEvent(FD_CLOSE, 0, TRUE);
  388.                     return;
  389.                 }
  390.                     
  391.                 if (m_nReceiveBufferSize < (len+4))
  392.                 {
  393.                     delete [] m_pReceiveBuffer;
  394.                     m_pReceiveBuffer = new char[len * 2 + 4];
  395.                     m_nReceiveBufferSize = len * 2 + 4;
  396.                 }
  397.                 memcpy(m_pReceiveBuffer, &len, 4);
  398.                 m_nReceiveBufferLen = 4;
  399.             }
  400.  
  401.             ASSERT(m_pReceiveBuffer);
  402.             int len = *(int*)m_pReceiveBuffer;
  403.             ASSERT(len>4 && len < (1024*1024*4));
  404.             int lenToReceive = len - m_nReceiveBufferLen + 4;
  405.  
  406.             int numread = ReceiveNext(m_pReceiveBuffer + m_nReceiveBufferLen, lenToReceive);
  407.  
  408.             if (!numread)
  409.             {
  410.                 m_nGssNetworkError = -1;
  411.                 if (!m_nDecryptedReceiveBufferLen)
  412.                     TriggerEvent(FD_CLOSE, 0, TRUE);
  413.                 return;
  414.             }
  415.             else if (numread == SOCKET_ERROR)
  416.             {
  417.                 if (GetLastError() != WSAEWOULDBLOCK)
  418.                 {
  419.                     m_nGssNetworkError = GetLastError();
  420.                     TriggerEvent(FD_CLOSE, 0, TRUE);
  421.                 }
  422.                 return;
  423.             }
  424.             m_nReceiveBufferLen += numread;
  425.                 
  426.             if (numread != lenToReceive)
  427.             {
  428.                 if (m_nDecryptedReceiveBufferLen)
  429.                     TriggerEvent(FD_READ, nErrorCode, TRUE);
  430.                 return;
  431.             }
  432.  
  433.             ASSERT(m_nReceiveBufferLen-4 == len);
  434.  
  435.             char * decBuffer = m_tmpBuffer;
  436.             if ((len*1.5) > (1024*32))
  437.                 decBuffer = new char[(int)(len * 1.5)];
  438.             memcpy(decBuffer, m_pReceiveBuffer+4, len);
  439.  
  440.             m_nReceiveBufferLen = 0;
  441.  
  442.             int nDecrypted = pFzGss_DecryptData(m_pData, decBuffer, len, sendme);
  443.             if (nDecrypted <= 0)
  444.             {
  445.                 if (!m_nDecryptedReceiveBufferLen)
  446.                     //Trigger OnClose()
  447.                     TriggerEvent(FD_CLOSE, 0, TRUE);
  448.                 
  449.                 if (decBuffer != m_tmpBuffer)
  450.                     delete [] decBuffer;
  451.                 return;
  452.             }
  453.  
  454.             //Add line to decrypted buffer
  455.             if (!m_pDecryptedReceiveBuffer)
  456.             {
  457.                 ASSERT(!m_nDecryptedReceiveBufferSize && !m_nDecryptedReceiveBufferLen);
  458.                 m_pDecryptedReceiveBuffer = new char[nDecrypted * 2];
  459.                 m_nDecryptedReceiveBufferSize = nDecrypted * 2;
  460.                 m_nDecryptedReceiveBufferLen = 0;
  461.             }
  462.             else if (m_nDecryptedReceiveBufferSize < (m_nDecryptedReceiveBufferLen+nDecrypted))
  463.             {
  464.                 char *tmp=m_pDecryptedReceiveBuffer;
  465.                 m_pDecryptedReceiveBuffer = new char[m_nDecryptedReceiveBufferSize + nDecrypted + 4096];
  466.                 m_nDecryptedReceiveBufferSize = m_nDecryptedReceiveBufferSize + nDecrypted + 4096;
  467.                 memcpy(m_pDecryptedReceiveBuffer, tmp, m_nDecryptedReceiveBufferLen);
  468.                 delete [] tmp;
  469.             }
  470.             memcpy(m_pDecryptedReceiveBuffer + m_nDecryptedReceiveBufferLen, decBuffer, nDecrypted);
  471.             m_nDecryptedReceiveBufferLen += nDecrypted;
  472.                 
  473.             if (decBuffer != m_tmpBuffer)
  474.                 delete [] decBuffer;
  475.         }
  476.         else 
  477.         {
  478.             if (m_nAwaitingReply == 1)
  479.             {
  480.                 ReceiveReply();
  481.                 return;
  482.             }
  483.             int numread = ReceiveNext(m_tmpBuffer, BUFSIZE);
  484.             if (!numread)
  485.             {
  486.                 m_nGssNetworkError = -1;
  487.  
  488.                 //Trigger OnClose()
  489.                 TriggerEvent(FD_CLOSE, 0, TRUE);
  490.                 return;
  491.             }
  492.             else if ( numread == SOCKET_ERROR )
  493.             {    
  494.                 if ( WSAGetLastError() != WSAEWOULDBLOCK )
  495.                 {
  496.                     m_nGssNetworkError = GetLastError();
  497.                     TriggerEvent(FD_CLOSE, 0, TRUE);
  498.                 }
  499.                 else if (m_nDecryptedReceiveBufferLen)
  500.                     TriggerEvent(FD_READ, 0, TRUE);
  501.                 return;
  502.             }
  503.             if (!m_pReceiveBuffer)
  504.             {
  505.                 ASSERT(!m_nReceiveBufferLen && !m_nReceiveBufferSize);
  506.                 m_pReceiveBuffer = new char[numread * 2];
  507.                 m_nReceiveBufferSize = numread * 2;
  508.             }
  509.             else if (m_nReceiveBufferSize < (m_nReceiveBufferLen + numread))
  510.             {
  511.                 char *tmp=m_pReceiveBuffer;
  512.                 m_pReceiveBuffer = new char[m_nReceiveBufferLen + numread + 4096];
  513.                 m_nReceiveBufferSize = m_nReceiveBufferLen + numread + 4096;
  514.                 memcpy(m_pReceiveBuffer, tmp, m_nReceiveBufferLen);
  515.                 delete [] tmp;
  516.             }
  517.             memcpy(m_pReceiveBuffer+m_nReceiveBufferLen, m_tmpBuffer, numread);
  518.             int nOldLen = m_nReceiveBufferLen;
  519.             m_nReceiveBufferLen += numread;
  520.  
  521.             //Now search for complete lines and decrypt them
  522.             for (unsigned int i = nOldLen; i < m_nReceiveBufferLen; i++)
  523.             {
  524.                 if (m_pReceiveBuffer[i] == '\n')
  525.                 {
  526.                     if (!i)
  527.                     {
  528.                         if (m_nReceiveBufferLen > 1)
  529.                             memmove(m_pReceiveBuffer, m_pReceiveBuffer+1, m_nReceiveBufferLen - 1);
  530.                         m_nReceiveBufferLen--;
  531.                         i--;
  532.                         continue;
  533.                     }
  534.                     if (m_pReceiveBuffer[i-1] == '\r')
  535.                     {
  536.                         //We've found a line
  537.  
  538.                         char *decBuffer = m_tmpBuffer;
  539.                         if ((i*1.5) > (1024*32))
  540.                             decBuffer = new char[(int)(i * 1.5)];
  541.                         memcpy(decBuffer, m_pReceiveBuffer, i-2);
  542.                         decBuffer[i-1] = '\0';
  543.  
  544.                         //Delete encrypted line from receive buffer
  545.                         if (!(m_nReceiveBufferLen-i-1))
  546.                             m_nReceiveBufferLen = 0;
  547.                         else
  548.                         {
  549.                             memmove(m_pReceiveBuffer, m_pReceiveBuffer+i+1, m_nReceiveBufferLen - i - 1);
  550.                             m_nReceiveBufferLen -= i + 1;
  551.                         }
  552.  
  553.                         // Decrypt line
  554.                         char *str = new char[strlen(decBuffer) + 30];
  555.                         sprintf(str, "Encrypted reply: %s", decBuffer);
  556.                         DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_INFO, (int)str);
  557.                         delete [] str;
  558.                         int nDecrypted = pFzGss_DecryptMessage(m_pData, decBuffer, sendme);
  559.                         if (!nDecrypted)
  560.                         {
  561.                             m_nGssNetworkError = -1;
  562.                             
  563.                             //Trigger OnClose()
  564.                             TriggerEvent(FD_CLOSE, 0, TRUE);
  565.                             
  566.                             if (decBuffer != m_tmpBuffer)
  567.                                 delete [] decBuffer;
  568.                             return;
  569.                         }
  570.                         nDecrypted = strlen(decBuffer);
  571.                     
  572.                         if (m_nAwaitingReply && m_nAwaitingReply<3)
  573.                         {
  574.                             while (decBuffer[nDecrypted - 1]=='\n' || decBuffer[nDecrypted - 1]=='\r')
  575.                                 nDecrypted--;
  576.                             decBuffer[nDecrypted] = 0;
  577.                             m_nAwaitingReply = 0;
  578.                             DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_REPLY, (int)decBuffer);
  579.                             if (decBuffer[nDecrypted - 1]!='\n')
  580.                             {
  581.                                 decBuffer[nDecrypted++]='\r';
  582.                                 decBuffer[nDecrypted++]='\n';
  583.                                 decBuffer[nDecrypted] = 0;
  584.                             }
  585.  
  586.                             int res = pFzGss_ProcessReply(m_pData, decBuffer);
  587.                             if (res == 1)
  588.                                 DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_AUTHCOMPLETE, 0);
  589.                             else if (res!=-1)
  590.                             {
  591.                                 m_gotAuth = 0;
  592.                                 DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_AUTHFAILED, 0);
  593.                             }
  594.                             if (decBuffer != m_tmpBuffer)
  595.                                 delete [] decBuffer;
  596.                         }
  597.                         else
  598.                         {
  599.                             if (decBuffer[nDecrypted - 1]!='\n')
  600.                             {
  601.                                 decBuffer[nDecrypted++]='\r';
  602.                                 decBuffer[nDecrypted++]='\n';
  603.                                 decBuffer[nDecrypted] = 0;
  604.                             }
  605.                             
  606.                             //Add line to decrypted buffer
  607.                             if (!m_pDecryptedReceiveBuffer)
  608.                             {
  609.                                 m_pDecryptedReceiveBuffer = new char[nDecrypted * 2];
  610.                                 m_nDecryptedReceiveBufferSize = nDecrypted * 2;
  611.                                 m_nDecryptedReceiveBufferLen=0;
  612.                             }
  613.                             else if (m_nDecryptedReceiveBufferSize < (m_nDecryptedReceiveBufferLen+nDecrypted))
  614.                             {
  615.                                 char *tmp=m_pDecryptedReceiveBuffer;
  616.                                 m_pDecryptedReceiveBuffer = new char[m_nDecryptedReceiveBufferSize + nDecrypted + 4096];
  617.                                 m_nDecryptedReceiveBufferSize = m_nDecryptedReceiveBufferSize + nDecrypted + 4096;
  618.                                 memcpy(m_pDecryptedReceiveBuffer, tmp, m_nDecryptedReceiveBufferLen);
  619.                                 delete [] tmp;
  620.                             }
  621.                             memcpy(m_pDecryptedReceiveBuffer + m_nDecryptedReceiveBufferLen, decBuffer, nDecrypted);
  622.                             m_nDecryptedReceiveBufferLen += nDecrypted;
  623.     
  624.                             if (decBuffer != m_tmpBuffer)
  625.                                 delete [] decBuffer;
  626.                         }
  627.                         
  628.                         //Try to decrypt any additional lines
  629.                         i=-1;
  630.                     }
  631.                 }
  632.             }
  633.         }
  634.     }
  635. }
  636.  
  637. void CAsyncGssSocketLayer::Close()
  638. {
  639.     CloseNext();
  640.     
  641.     m_nAwaitingReply = 0;
  642.     m_nGssNetworkError=0;
  643.     if (!m_transfer)
  644.         m_gotAuth = 0;
  645.  
  646.     m_nSendBufferLen = 0;
  647.  
  648.     m_nReceiveBufferLen = 0;
  649.     m_nDecryptedReceiveBufferLen = 0;
  650.  
  651.     KillGSSData();
  652. }
  653.  
  654. BOOL CAsyncGssSocketLayer::UnLoadGSSLibrary()
  655. {
  656.     if (m_hGSS_API)
  657.     {
  658.         FreeLibrary(m_hGSS_API);
  659.         m_hGSS_API = NULL;
  660.     }
  661.     return TRUE;
  662. }
  663.  
  664.  
  665. BOOL CAsyncGssSocketLayer::LoadGSSLibrary()
  666. {
  667.     if (m_hGSS_API)
  668.         return TRUE;
  669.  
  670.     m_hGSS_API = LoadLibrary(GFTPDLL);
  671.     return !(m_hGSS_API==NULL); 
  672.     
  673. }
  674.  
  675. BOOL CAsyncGssSocketLayer::InitGSS(BOOL bSpawned, BOOL promptPassword)
  676. {
  677.     if (m_bUseGSS)
  678.         return TRUE;
  679.  
  680.     if (m_bInitialized)
  681.         return TRUE;
  682.  
  683.     if (!m_hGSS_API)
  684.         LoadGSSLibrary();
  685.     
  686.     if (!m_hGSS_API)
  687.         return FALSE;
  688.     
  689.     if (m_hGSS_API)
  690.     {
  691.         pFzGss_ProcessCommand    = (t_FzGss_ProcessCommand)GetProcAddress(m_hGSS_API, "ProcessCommand");
  692.         pFzGss_DecryptMessage    = (t_FzGss_DecryptMessage)GetProcAddress(m_hGSS_API, "DecryptMessage");
  693.         pFzGss_EncryptMessage    = (t_FzGss_EncryptMessage)GetProcAddress(m_hGSS_API, "EncryptMessage");
  694.         pFzGss_EncryptData        = (t_FzGss_EncryptData)GetProcAddress(m_hGSS_API , "EncryptData");
  695.         pFzGss_DecryptData        = (t_FzGss_DecryptData)GetProcAddress(m_hGSS_API, "DecryptData");
  696.         pFzGss_InitGSS            = (t_FzGss_InitGSS)GetProcAddress(m_hGSS_API, "InitGSS");
  697.         pFzGss_KillGSS            = (t_FzGss_KillGSS)GetProcAddress(m_hGSS_API, "KillGSS");
  698.         pFzGss_DoClientAuth        = (t_FzGss_DoClientAuth)GetProcAddress(m_hGSS_API, "DoClientAuth");
  699.         pFzGss_ProcessReply        = (t_FzGss_ProcessReply)GetProcAddress(m_hGSS_API, "ProcessReply");
  700.         pFzGss_GetUserFromKrbTicket = (t_FzGss_GetUserFromKrbTicket)GetProcAddress(m_hGSS_API, "GetUserFromKrbTicket");
  701.         
  702.         if (!pFzGss_ProcessCommand || !pFzGss_InitGSS || !pFzGss_KillGSS||
  703.             !pFzGss_DecryptMessage || !pFzGss_EncryptMessage || !pFzGss_EncryptData ||
  704.             !pFzGss_DecryptData        ||
  705.             !pFzGss_DoClientAuth    ||
  706.             !pFzGss_ProcessReply    ||
  707.             !pFzGss_GetUserFromKrbTicket
  708.             )
  709.         {
  710.             return FALSE;
  711.         }
  712.     }
  713.  
  714.     if (!bSpawned)
  715.     {
  716.         m_pData=new void*;
  717.         if (!pFzGss_InitGSS(m_pData, Callback, this, promptPassword))
  718.         {
  719.             UnLoadGSSLibrary();
  720.             return FALSE;
  721.         }
  722.     }
  723.     
  724.     if (!bSpawned)
  725.         m_bInitialized = TRUE;
  726.  
  727.     m_bUseGSS = TRUE;
  728.     
  729.     return TRUE;
  730. }
  731.  
  732. BOOL CAsyncGssSocketLayer::KillGSSData()
  733. {
  734.     if (!m_bUseGSS)
  735.         return FALSE;
  736.  
  737.     if (!m_bInitialized)
  738.         return TRUE;
  739.  
  740.     m_bUseGSS = FALSE;
  741.  
  742.     pFzGss_KillGSS(m_pData);
  743.     m_bInitialized = FALSE;
  744.     delete m_pData;
  745.     m_pData = NULL;
  746.     
  747.     UnLoadGSSLibrary();
  748.  
  749.     return TRUE;
  750. }
  751.  
  752. BOOL CAsyncGssSocketLayer::InitTransferChannel(CAsyncGssSocketLayer *pSocket)
  753. {
  754.     KillGSSData();
  755.     InitGSS(TRUE);
  756.     m_pData = pSocket->m_pData;
  757.     m_bUseGSS = pSocket->m_bUseGSS;
  758.     m_gotAuth = pSocket->m_gotAuth;
  759.     m_transfer = TRUE;
  760.     return TRUE;
  761. }
  762.  
  763. void CAsyncGssSocketLayer::OnSend(int nErrorCode)
  764. {
  765.     if (!m_nSendBufferLen)
  766.         TriggerEvent(FD_WRITE, nErrorCode, TRUE);
  767.     else
  768.     {
  769.         ASSERT(m_pSendBuffer);
  770.         int numsent = SendNext(m_pSendBuffer, m_nSendBufferLen, 0);
  771.         if (!numsent)
  772.             TriggerEvent(FD_CLOSE, nErrorCode, TRUE);
  773.         else if (numsent == SOCKET_ERROR)
  774.         {
  775.             if (GetLastError() != WSAEWOULDBLOCK)
  776.                 TriggerEvent(FD_CLOSE, nErrorCode, TRUE);
  777.         }
  778.         else if (numsent != m_nSendBufferLen)
  779.         {
  780.             memmove(m_pSendBuffer, m_pSendBuffer + numsent, m_nSendBufferLen - numsent);
  781.             m_nSendBufferLen -= numsent;
  782.         }
  783.         else
  784.         {
  785.             m_nSendBufferLen = 0;
  786.             if (ShutDownComplete())
  787.                 DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_SHUTDOWN_COMPLETE, 0);
  788.             else
  789.                 TriggerEvent(FD_WRITE, nErrorCode, TRUE);
  790.         }
  791.     }
  792. }
  793.  
  794. BOOL CAsyncGssSocketLayer::ShutDown(int nHow /*=sends*/)
  795. {
  796.     if (m_gotAuth == GSSAPI_AUTHENTICATION_SUCCEEDED && m_bUseGSS)
  797.     {
  798.         if (m_nShutDown)
  799.         {
  800.             if (m_nSendBufferLen)
  801.                 return FALSE;
  802.             else
  803.                 return TRUE;
  804.         }
  805.         m_nShutDown = 1;
  806.  
  807.         char sendme[4096];
  808.         char *encBuffer = m_tmpBuffer;
  809.         int encBufferLen = 0;
  810.  
  811.         encBufferLen = pFzGss_EncryptData(m_pData, encBuffer, 0, sendme);
  812.         if (!encBufferLen)
  813.         {
  814.             WSASetLastError(WSAENETDOWN);
  815.             return FALSE;
  816.         }
  817.         
  818.         encBuffer[encBufferLen++] = '\r';
  819.         encBuffer[encBufferLen++] = '\n';
  820.  
  821.         if (m_nSendBufferLen)
  822.         {
  823.             ASSERT(m_pSendBuffer);
  824.             int numsent = SendNext(m_pSendBuffer, m_nSendBufferLen, 0);
  825.             if (!numsent)
  826.                 return TRUE;
  827.             else if (numsent == SOCKET_ERROR && GetLastError()!=WSAEWOULDBLOCK)
  828.                 return TRUE;
  829.             else if (numsent != m_nSendBufferLen)
  830.             {
  831.                 if (numsent == SOCKET_ERROR)
  832.                     numsent = 0;
  833.                 if (m_nSendBufferSize < (m_nSendBufferLen + encBufferLen))
  834.                 {
  835.                     char *tmp = m_pSendBuffer;
  836.                     m_pSendBuffer = new char[m_nSendBufferSize + encBufferLen + 4096];
  837.                     m_nSendBufferSize = m_nSendBufferSize + encBufferLen + 4096;
  838.                     memcpy(m_pSendBuffer, tmp+numsent, m_nSendBufferLen-numsent);
  839.                     delete [] tmp;
  840.                 }
  841.                 else
  842.                     memmove(m_pSendBuffer, m_pSendBuffer + numsent, m_nSendBufferLen - numsent);
  843.                 memcpy(m_pSendBuffer + m_nSendBufferLen-numsent, encBuffer, encBufferLen);
  844.                 m_nSendBufferLen += encBufferLen-numsent;
  845.  
  846.                 WSASetLastError(WSAEWOULDBLOCK);
  847.                 return FALSE;
  848.             }
  849.             else
  850.                 m_nSendBufferLen = 0;
  851.         }
  852.  
  853.         int numsent = SendNext(encBuffer, encBufferLen, 0);
  854.         if (!numsent)
  855.             return TRUE;
  856.         if (numsent == SOCKET_ERROR)
  857.         {
  858.             if (GetLastError() == WSAEWOULDBLOCK)
  859.             {
  860.                 if (m_nSendBufferSize < encBufferLen)
  861.                 {
  862.                     delete [] m_pSendBuffer;
  863.                     m_pSendBuffer = new char[encBufferLen * 2];
  864.                     m_nSendBufferLen = encBufferLen * 2;
  865.                 }
  866.  
  867.                 memcpy(m_pSendBuffer, encBuffer, encBufferLen);
  868.                 m_nSendBufferLen = encBufferLen;
  869.                 return FALSE;
  870.             }
  871.             return TRUE;
  872.         }
  873.  
  874.         if (numsent != encBufferLen)
  875.         {
  876.             if (m_nSendBufferSize < encBufferLen)
  877.             {
  878.                 delete [] m_pSendBuffer;
  879.                 m_pSendBuffer = new char[encBufferLen * 2];
  880.                 m_nSendBufferSize = encBufferLen * 2;
  881.             }
  882.             memcpy(m_pSendBuffer, encBuffer+numsent, encBufferLen-numsent);
  883.             m_nSendBufferLen = encBufferLen-numsent;
  884.         }
  885.  
  886.         if (m_nSendBufferLen)
  887.         {
  888.             WSASetLastError(WSAEWOULDBLOCK);
  889.             return FALSE;
  890.         }
  891.         else
  892.             return TRUE;
  893.     }
  894.     else
  895.         return ShutDownNext();
  896. }
  897.  
  898. BOOL CAsyncGssSocketLayer::ShutDownComplete()
  899. {
  900.     //If a ShutDown was issued, has the connection already been shut down?
  901.     if (!m_nShutDown)
  902.         return FALSE;
  903.     else if (m_gotAuth != GSSAPI_AUTHENTICATION_SUCCEEDED || !m_bUseGSS)
  904.         return FALSE;
  905.     else if (m_nSendBufferLen)
  906.         return FALSE;
  907.     else
  908.         return TRUE;
  909. }
  910.  
  911. int CAsyncGssSocketLayer::ProcessCommand(const char *command, const char *args, char *sendme)
  912. {
  913.     ASSERT(command);
  914.     ASSERT(sendme);
  915.  
  916.     if (!m_bUseGSS)
  917.     {
  918.         strcpy(sendme, "501 GSSAPI not initialized");
  919.         return -1;
  920.     }
  921.     
  922.     char *argBuffer = m_tmpBuffer;
  923.     if ((strlen(args) + 1000) >= (1024*32))
  924.         argBuffer = new char[strlen(args) + 1000];
  925.     
  926.     if (!strcmp(command, "ADAT"))
  927.     {
  928.         SOCKADDR_IN his_addr;
  929.         SOCKADDR_IN ctrl_addr;
  930.         
  931.         int addrlen = sizeof (his_addr);
  932.         if (!GetPeerName((SOCKADDR*)&his_addr, &addrlen))
  933.         {
  934.             if (argBuffer != m_tmpBuffer)
  935.                 delete [] argBuffer;
  936.             sprintf(sendme, "501 unable to getpeername");
  937.             return -1;
  938.         }
  939.         
  940.         addrlen = sizeof (ctrl_addr);
  941.         if (!GetSockName((SOCKADDR*)&ctrl_addr, &addrlen))
  942.         {
  943.             if (argBuffer != m_tmpBuffer)
  944.                 delete [] argBuffer;
  945.             sprintf(sendme, "501 unable to getsockname");
  946.             return -1;
  947.         }
  948.         
  949.         char localname[513];
  950.         struct hostent *hp;
  951.  
  952.         if (gethostname(localname, 512))
  953.         {
  954.             if (argBuffer != m_tmpBuffer)
  955.                 delete [] argBuffer;
  956.             sprintf(sendme, "501 couldn't get local hostname (%d)", errno);
  957.             return -1;
  958.         }
  959.         
  960.         hp = gethostbyname(localname);
  961.         if (!hp) 
  962.         {
  963.             if (argBuffer != m_tmpBuffer)
  964.                 delete [] argBuffer;
  965.             sprintf(sendme, "501 couldn't canonicalize local hostname");
  966.             return -1;
  967.         }
  968.         strncpy(localname, hp->h_name, sizeof(localname) - 1);
  969.         localname[sizeof(localname) - 1] = '\0';
  970.         
  971.         memcpy(argBuffer, &his_addr.sin_addr.s_addr, 4);
  972.         memcpy(argBuffer+4, &ctrl_addr.sin_addr.s_addr, 4);
  973.         strcpy(argBuffer + 8, localname);
  974.         strcpy(argBuffer + 8 + strlen(localname) + 1, args);
  975.     }
  976.     else
  977.         strcpy(argBuffer, args);
  978.  
  979.     int res = pFzGss_ProcessCommand(m_pData, command, argBuffer, sendme);
  980.  
  981.     if (!strcmp(command, "ADAT") && res != -1)
  982.     {
  983.         m_nAwaitingReply = 3;
  984.         m_gotAuth = GSSAPI_AUTHENTICATION_SUCCEEDED;
  985.     }
  986.     
  987.     if (argBuffer != m_tmpBuffer)
  988.         delete [] argBuffer;
  989.  
  990.     return res;
  991. }
  992.  
  993. BOOL CAsyncGssSocketLayer::AuthSuccessful() const
  994. {
  995.     return m_gotAuth == GSSAPI_AUTHENTICATION_SUCCEEDED;
  996. }
  997.  
  998. int CAsyncGssSocketLayer::ProcessCommand(const char *command, const char *args1, const char *args2, char *sendme)
  999. {
  1000.     ASSERT(command);
  1001.     ASSERT(sendme);
  1002.  
  1003.     if (!m_bUseGSS)
  1004.     {
  1005.         strcpy(sendme, "501 GSSAPI not initialized");
  1006.         return -1;
  1007.     }
  1008.     
  1009.     char *argBuffer = m_tmpBuffer;
  1010.     if ((strlen(args1) + strlen(args2) + 10) >= (1024*32))
  1011.         argBuffer = new char[strlen(args1) + strlen(args2) + 10];
  1012.     
  1013.     strcpy(argBuffer, args1);
  1014.     strcpy(argBuffer + strlen(args1) + 1, args2);
  1015.  
  1016.     int res = pFzGss_ProcessCommand(m_pData, command, argBuffer, sendme);
  1017.  
  1018.     if (!strcmp(command, "ADAT") && res != -1)
  1019.         m_gotAuth = GSSAPI_AUTHENTICATION_SUCCEEDED;
  1020.     
  1021.     if (argBuffer != m_tmpBuffer)
  1022.         delete [] argBuffer;
  1023.  
  1024.     return res;
  1025. }
  1026.  
  1027. int CAsyncGssSocketLayer::GetClientAuth(const char* pHost)
  1028. {
  1029.     if (m_hGSS_API)
  1030.     {
  1031.         char *hostname;
  1032.         int res;
  1033.         
  1034.         hostname = new char[strlen(pHost)+1];
  1035.         strcpy(hostname, pHost);
  1036.     
  1037.         memset(&m_myAddr, 0, sizeof(m_myAddr));
  1038.         int SockAddrLen = sizeof(m_myAddr);
  1039.         if (!GetPeerName(&m_myAddr, &SockAddrLen))
  1040.         {
  1041.             DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_ERROR, (int)"GetAuth() GetPeerName() failed");
  1042.             return FALSE;
  1043.         }
  1044.                 
  1045.         memset(&m_hisAddr, 0, sizeof(m_hisAddr));
  1046.         if (!GetSockName(&m_hisAddr, &SockAddrLen))
  1047.         {
  1048.             DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_ERROR, (int)"GetAuth() GetSockName() failed");
  1049.             return FALSE;
  1050.         }
  1051.                 
  1052.         res = pFzGss_DoClientAuth(m_pData, hostname,
  1053.             &m_myAddr,
  1054.             &m_hisAddr,
  1055.             'P', 0);
  1056.         
  1057.         m_gotAuth = res;
  1058.         if (m_gotAuth == -1)
  1059.             m_gotAuth = 1;
  1060.         delete [] hostname;
  1061.         return res;
  1062.     }
  1063.     else
  1064.     {
  1065.         DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_ERROR, (int)"GetClientAuth(933): GSS api not initialized!");
  1066.         m_gotAuth = 0;//SEND_DATA_IN_THE_CLEAR;
  1067.     }
  1068.     return m_gotAuth;
  1069. }
  1070.  
  1071. void CAsyncGssSocketLayer::OnClose(int nErrorCode)
  1072. {
  1073.     if (!m_nGssNetworkError)
  1074.         m_nGssNetworkError = -1;
  1075.     if (!nErrorCode)
  1076.         OnReceive(0);
  1077.     if (!m_nDecryptedReceiveBufferLen)
  1078.         TriggerEvent(FD_CLOSE, nErrorCode, TRUE);
  1079. }
  1080.  
  1081. int CALLBACK CAsyncGssSocketLayer::Callback(void *pData, int nParam1, int nParam2, int nParam3)
  1082. {
  1083.     CAsyncGssSocketLayer *pLayer = reinterpret_cast<CAsyncGssSocketLayer *>(pData);
  1084.     switch (nParam1)
  1085.     {
  1086.     case 0:
  1087.         pLayer->DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_INFO, nParam2);
  1088.         break;
  1089.     case 1:
  1090.         {
  1091.             char *buffer = (char *)nParam2;
  1092.             int len = strlen(buffer);
  1093.             if (nParam3)
  1094.             {
  1095.                 pLayer->DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_COMMAND, nParam3);
  1096.                 char *str = new char[strlen((char *)nParam2)+25];
  1097.                 sprintf(str, "Encrypted command: %s", (char *)nParam2);
  1098.                 pLayer->DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_INFO, (int)str);
  1099.                 delete [] str;
  1100.             }
  1101.             else
  1102.                 pLayer->DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_COMMAND, nParam2);
  1103.             pLayer->m_nAwaitingReply = nParam3 ? 2:1;
  1104.     
  1105.             if (!pLayer->m_pSendBuffer)
  1106.             {
  1107.                 pLayer->m_pSendBuffer = new char[len + 4096];
  1108.                 pLayer->m_nSendBufferSize = len + 4096;
  1109.             }
  1110.             else if (pLayer->m_nSendBufferSize < (pLayer->m_nSendBufferLen + len + 2))
  1111.             {
  1112.                 char *tmp = pLayer->m_pSendBuffer;
  1113.                 pLayer->m_pSendBuffer = new char[pLayer->m_nSendBufferLen + len + 4096];
  1114.                 pLayer->m_nSendBufferSize = pLayer->m_nSendBufferLen + len + 4096;
  1115.                 memcpy(pLayer->m_pSendBuffer, tmp, pLayer->m_nSendBufferLen);
  1116.                 delete [] tmp;
  1117.             }
  1118.  
  1119.             memcpy(pLayer->m_pSendBuffer+pLayer->m_nSendBufferLen, (char *)nParam2, len);
  1120.             pLayer->m_pSendBuffer[pLayer->m_nSendBufferLen+len] = '\r';
  1121.             pLayer->m_pSendBuffer[pLayer->m_nSendBufferLen+len+1] = '\n';
  1122.             pLayer->m_nSendBufferLen += len + 2;
  1123.             pLayer->TriggerEvent(FD_WRITE, 0);
  1124.             break;
  1125.         }
  1126.     }
  1127.     return 0;
  1128. }
  1129.  
  1130. void CAsyncGssSocketLayer::ReceiveReply()
  1131. {
  1132.     if (m_nReceiveBufferSize < 4096)
  1133.     {
  1134.         delete [] m_pReceiveBuffer;
  1135.         m_pReceiveBuffer = new char[4096];
  1136.         m_nReceiveBufferSize = 4096;
  1137.     }
  1138.  
  1139.     char buffer;
  1140.     int numread = ReceiveNext(&buffer, 1);
  1141.     if (!numread)
  1142.     {
  1143.         m_nGssNetworkError = -1;
  1144.         
  1145.         //Trigger OnClose()
  1146.         TriggerEvent(FD_CLOSE, 0, TRUE);
  1147.         return;
  1148.     }
  1149.     else if ( numread == SOCKET_ERROR )
  1150.     {    
  1151.         if ( WSAGetLastError() != WSAEWOULDBLOCK )
  1152.         {
  1153.             m_nGssNetworkError = GetLastError();
  1154.             TriggerEvent(FD_CLOSE, 0, TRUE);
  1155.         }
  1156.         else if (m_nDecryptedReceiveBufferLen)
  1157.             TriggerEvent(FD_READ, 0, TRUE);
  1158.         return;
  1159.     }
  1160.     if (buffer == 0 || buffer=='\r' || buffer=='\n')
  1161.     {
  1162.         if (!m_nReceiveBufferLen)
  1163.             return;
  1164.         m_nAwaitingReply = 0;
  1165.         m_pReceiveBuffer[m_nReceiveBufferLen] = 0;    
  1166.         DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_REPLY, (int)m_pReceiveBuffer);
  1167.         int res = pFzGss_ProcessReply(m_pData, m_pReceiveBuffer);
  1168.         m_nReceiveBufferLen = 0;
  1169.         if (res == 1)
  1170.             DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_AUTHCOMPLETE, 0);
  1171.         else if (res==-1)
  1172.             return;
  1173.         else
  1174.         {
  1175.             m_gotAuth = 0;
  1176.             DoLayerCallback(LAYERCALLBACK_LAYERSPECIFIC, GSS_AUTHFAILED, 0);
  1177.         }
  1178.     }
  1179.     else if (m_nReceiveBufferLen < 4095)
  1180.         m_pReceiveBuffer[m_nReceiveBufferLen++] = buffer;
  1181. }
  1182.  
  1183. BOOL CAsyncGssSocketLayer::GetUserFromKrbTicket(char *buffer)
  1184. {
  1185.     if (!m_gotAuth || !m_bUseGSS || !m_pData || !pFzGss_GetUserFromKrbTicket)
  1186.         return FALSE;
  1187.  
  1188.     return pFzGss_GetUserFromKrbTicket(m_pData, buffer);
  1189. }
  1190.